基址|都会_中断处理流程梳理

篇首语：本文由编程笔记#小编为大家整理，主要介绍了中断处理流程梳理相关的知识，希望对你有一定的参考价值。

在之前的ARMv8-A的异常文章中提到&＃xff0c;ARMv8-A将中断也当做一种异常&＃xff0c;中断分为IRQ和FIQ

假设当前在EL0运行一个64位的应用程序&＃xff0c;触发了一个EL0的IRQ中断&＃xff0c;则处理器会做如下的操作

• 将CPU的状态PSTATE保存到SPSR_EL1寄存器中&＃xff0c;PC保存到ELR_EL1寄存器中
• 跳到异常的处理函数处

则就会跳到ARM64对应的异常向量表

/*
* Exception vectors.
*/
.pushsection ".entry.text", "ax"

.align 11
ENTRY(vectors)
kernel_ventry 1, sync_invalid // Synchronous EL1t
kernel_ventry 1, irq_invalid // IRQ EL1t
kernel_ventry 1, fiq_invalid // FIQ EL1t
kernel_ventry 1, error_invalid // Error EL1t

kernel_ventry 1, sync // Synchronous EL1h
kernel_ventry 1, irq // IRQ EL1h
kernel_ventry 1, fiq_invalid // FIQ EL1h
kernel_ventry 1, error // Error EL1h

kernel_ventry 0, sync // Synchronous 64-bit EL0
kernel_ventry 0, irq // IRQ 64-bit EL0
kernel_ventry 0, fiq_invalid // FIQ 64-bit EL0
kernel_ventry 0, error // Error 64-bit EL0

#ifdef CONFIG_COMPAT
kernel_ventry 0, sync_compat, 32 // Synchronous 32-bit EL0
kernel_ventry 0, irq_compat, 32 // IRQ 32-bit EL0
kernel_ventry 0, fiq_invalid_compat, 32 // FIQ 32-bit EL0
kernel_ventry 0, error_compat, 32 // Error 32-bit EL0
#else
kernel_ventry 0, sync_invalid, 32 // Synchronous 32-bit EL0
kernel_ventry 0, irq_invalid, 32 // IRQ 32-bit EL0
kernel_ventry 0, fiq_invalid, 32 // FIQ 32-bit EL0
kernel_ventry 0, error_invalid, 32 // Error 32-bit EL0
#endif
END(vectors)

因为是EL0触发的异常&＃xff0c;而且异常状态是IRQ&＃xff0c;则会根据异常向量表的基址跳大EL0_irq处&＃xff0c; kernel_ventry 0, irq // IRQ 64-bit EL0

el0_irq:
kernel_entry 0
el0_irq_naked:
enable_da_f

irq_handler
b ret_to_user
ENDPROC(el0_irq)

kernel_entry 0&＃xff0c;其中kernel_entry是一个宏&＃xff0c;此宏会保存当前的线程&＃xff0c;也就是进程的寄存器

stp x0, x1, [sp, #16 * 0]
stp x2, x3, [sp, #16 * 1]
stp x4, x5, [sp, #16 * 2]
stp x6, x7, [sp, #16 * 3]
stp x8, x9, [sp, #16 * 4]
stp x10, x11, [sp, #16 * 5]
stp x12, x13, [sp, #16 * 6]
stp x14, x15, [sp, #16 * 7]
stp x16, x17, [sp, #16 * 8]
stp x18, x19, [sp, #16 * 9]
stp x20, x21, [sp, #16 * 10]
stp x22, x23, [sp, #16 * 11]
stp x24, x25, [sp, #16 * 12]
stp x26, x27, [sp, #16 * 13]
stp x28, x29, [sp, #16 * 14]

enable_da_f 这个在ARM处理器状态由描述&＃xff0c;DAIF。这里是关闭IRQ中断

/* IRQ is the lowest priority flag, unconditionally unmask the rest. */
.macro enable_da_f
msr daifclr, #(8 | 4 | 1)
.endm

• 跳转到irq_handler去处理中断
• 当中断处理完毕后&＃xff0c;就会通过ret_to_user返回到用户空间

/*
* Interrupt handling.
*/
.macro irq_handler
ldr_l x1, handle_arch_irq
mov x0, sp
irq_stack_entry
blr x1
irq_stack_exit
.endm

.text

• 将handle_arch_irq设置到x1, 而handle_arch_irq就是上一篇在gic驱动中设置的。set_handle_irq(gic_handle_irq);
• 从进程的内核栈切换到中断栈

.macro irq_stack_entry
mov x19, sp // preserve the original sp

/*
* Compare sp with the base of the task stack.
* If the top ~(THREAD_SIZE - 1) bits match, we are on a task stack,
* and should switch to the irq stack.
*/
ldr x25, [tsk, TSK_STACK]
eor x25, x25, x19
and x25, x25, #~(THREAD_SIZE - 1)
cbnz x25, 9998f

ldr_this_cpu x25, irq_stack_ptr, x26
mov x26, #IRQ_STACK_SIZE
add x26, x25, x26

/* switch to the irq stack */
mov sp, x26
9998:
.endm

其中irq_stack_ptr就是中断栈&＃xff0c;每一个cpu都会存在一个中断栈的。

DEFINE_PER_CPU_ALIGNED(unsigned long [IRQ_STACK_SIZE/sizeof(long)], irq_stack);

static void init_irq_stacks(void)
int cpu;

for_each_possible_cpu(cpu)
per_cpu(irq_stack_ptr, cpu) &＃61; per_cpu(irq_stack, cpu);


当切换到中断栈之后&＃xff0c;则会跳到handle_arch_irq&＃xff0c;则就会跳到之前设置的gic_handle_irq中。

static asmlinkage void __exception_irq_entry gic_handle_irq(struct pt_regs *regs)
u32 irqnr;

do
irqnr &＃61; gic_read_iar();

if (likely(irqnr > 15 && irqnr <1020) || irqnr >&＃61; 8192)
int err;

uncached_logk(LOGK_IRQ, (void *)(uintptr_t)irqnr);
if (static_branch_likely(&supports_deactivate_key))
gic_write_eoir(irqnr);
else
isb();

err &＃61; handle_domain_irq(gic_data.domain, irqnr, regs); //处理中断
if (err)
WARN_ONCE(true, "Unexpected interrupt received!\\n");
if (static_branch_likely(&supports_deactivate_key))
if (irqnr <8192)
gic_write_dir(irqnr);
else
gic_write_eoir(irqnr);


continue;


假设当前的中断类型是SPI&＃xff0c;则会进入到hanle_domian_irq中去

int __handle_domain_irq(struct irq_domain *domain, unsigned int hwirq,
bool lookup, struct pt_regs *regs)
struct pt_regs *old_regs &＃61; set_irq_regs(regs);
unsigned int irq &＃61; hwirq;
int ret &＃61; 0;

irq_enter();

#ifdef CONFIG_IRQ_DOMAIN
if (lookup)
irq &＃61; irq_find_mapping(domain, hwirq);
#endif

/*
* Some hardware gives randomly wrong interrupts. Rather
* than crashing, do something sensible.
*/
if (unlikely(!irq || irq >&＃61; nr_irqs))
ack_bad_irq(irq);
ret &＃61; -EINVAL;
else
generic_handle_irq(irq);


irq_exit();
set_irq_regs(old_regs);
return ret;
#endif

• irq_enter则是代表进入中断上下文
• 然后根据hwirq和domain&＃xff0c;其中此domain是root domain&＃xff0c;则寻找到hwirq对应的softirq
• 如果此softirq 属于非法irq&＃xff0c;则发回bad ack
• 否则调用generic_handle_irq函数
• 当处理完毕后&＃xff0c;会退出中断上下文

int generic_handle_irq(unsigned int irq)
struct irq_desc *desc &＃61; irq_to_desc(irq);

if (!desc)
return -EINVAL;
generic_handle_irq_desc(desc);
return 0;


根据softirq 获取此中断的中断描述符&＃xff0c;调用generic_handle_irq_desc去处理中断&＃xff0c;后面会涉及到irq domain的知识了。后面详细说